MacWorld 1997 September/Macworld (1997-09).dmg/Shareware World/Utilities/User Interface/Sloop 68K 1.0.2/Sloop Extras/PopApp Source 1.0b2.sit/PopApp Source 1.0b2/popApp.c

C/C++ Source or Header | 1997-07-13 | 13KB | 421 lines

#pragma mark Top of file
/*
        PopApp (Application popup menu)
        Version 1.0b2
        ©1997 Graham Herrick

            This source code may be freely distributed without modification
        as long as this notice remains intact.
            If you use this code without modification in any software -- whether
        freeware, shareware, or commercial, you should acknowledge my copyright
        in your documentation and "about box".
            You may also modify this code as you see fit. If you modify it and
        still want to attribute it to me, please make note of the fact that your
        project includes a "modified" version of this code.

        Part of *this* code (the assembly shell) uses modified sample
        code from Apple DTS (jGNEHelper), the only modification being to
        fix the nil filter bug.

        Obviously, the ShowInitIcon code by Peter Lewis, Jim Walker, and
        François Pottier isn't mine either -- see that file for more info.

        If you find any bugs in my code, please let me know. This is still a beta version.

        Here are the CodeWarrior project settings in case you don't have the project file
        or you don't have CW 12 (CW Pro 1). Make a single 68K target.
        Include:
            popApp.c
            ShowInitIcon.c
            MacOS.lib
            PopApp.µ.rsrc
        68K Target settings:
            Project type:    Code Resource
            Creator:        PopA
            Type:            INIT
            ResType:        INIT
            ResID:            128
            Res Flags:        System heap and locked
            Header type:    Standard
            Check boxes unchecked
        C/C++ Language
            Just leave it at CodeWarrior default
            (everything unchecked except require function prototypes)
            Prefix whatever you want or use default as long as Universal headers are prefixed somehow
        C/C++ Warnings
            I always like to turn everything on
        68K Processor
            Code model:        Small
            Struct Align:    68K
            Float:            doesn't matter
            Check these boxes:
            4 byte ints
            8 byte doubled
            68020 Codegen if you want
            Peephole and CSE optimizers
            Optimize for size
            PC-relative strings
            Global register allocation
        68K Linker
            Symbols:        None (unless you want them of course)
            SYM file: do what you want
            Do not generate A6 stack frames
            Fast link
            Link single segment
            Merge compiler glue
            Dead-strip static initialization code
        That's it. The most important things are:
            All 68K target settings, small code model, 68K structs, link single segment and merge glue

        Version history:
        1997-05-10    Wrote the initial code
        1997-05-13    Removed some things
        1997-05-14    Started to clean it up for public release
        1997-07-01    Reverted assembly to be closer to Apple sample code
        1997-07-13    Cleaned up a bit, wrote some more comments -- ready to release with Sloop 1.0.2
*/

#pragma mark Includes
// Note: This is essentially a CodeWarrior file
// You'll have to redo a fair amount to make it work with something else
// It's also, obviously, only 68K code. PPC jGNEFilters are different (and more difficult)
#include <SetUpA4.h>
#include <A4Stuff.h>
#include "ShowInitIcon.h"

#pragma mark Constants
#define kMyMenuID            23451    // this is arbitary -- it should actually check to find a free ID
                                    // on the off chance that someone else is using this ID
#define kAppMenuID            -16489
#define resGoodInitIcon        128
#define resBadInitIcon        129

#pragma mark Types
typedef struct
{
    MenuHandle        menuoH;            // menu handle
    SInt16            menuLeft;        // left edge of menu
} MenuRec;

typedef struct
{
    SInt16            lastMenu;        // offset to last menu handle
    SInt16            lastRight;        // right edge of last menu's title
    SInt16            notUsed;
    MenuRec            mArray[];        // array of menus
} MenuList, *MenuListPtr, **MenuListHdl;

#pragma mark Globals
MenuHandle            myMenu;
void                *gOldJGNE;
Boolean                inJGNE;

#pragma mark Prototypes
// jGNE Stuff
pascal asm void myJGNEShell(void);
Boolean myGNE(EventRecord *event, Boolean result);
// Menu handling
MenuHandle FindTheAppMenu(MenuListHdl theList);
SInt32 SetUpTheMenu(MenuHandle appMenu, SInt32 *sepItemNum);
void TearDownTheMenu(SInt32 numItems);
void RespondToTheMenu(SInt16 item, SInt32 numItems, MenuHandle appMenu, SInt32 sepItemNum);
// String utilities
Boolean pStrComp(StringPtr p1, StringPtr p2);
void pStrCopy(StringPtr p1, StringPtr p2);

#pragma mark Macros
#define IsValidHandle(h)            (h && HandleZone((Handle)h) && !MemError() && *h)
#define StuffIntoLong(high,low)        (((((UInt32)high)<<16) & 0xFFFF0000)|(0x0000FFFF & (UInt32)low))
#define HighWord(n)                    ((n>>16) & 0x0000FFFF)
#define LowWord(n)                    (n & 0x0000FFFF)

#pragma mark -

// This gets called when the INIT starts up

void main(void)
{
    Handle        myInit = 0L;
    THz            theZ;
    SInt32        oldA4;

    // set up stuff
    oldA4 = SetCurrentA4();
    RememberA4();
    myMenu = 0L;

    // make sure the resource itself is marked system heap and locked!
    myInit = Get1Resource('INIT',128);
    if (!myInit) goto fail;

    // allocate globals in the system heap
    theZ = GetZone();
    SetZone(SystemZone());
    myMenu = NewMenu(kMyMenuID,"\pPopApp Menu");
    SetZone(theZ);
    if (!myMenu) goto fail;
    inJGNE = false;

    // install the jGNE filter
    gOldJGNE = LMGetGNEFilter();
    LMSetGNEFilter(myJGNEShell);

    // detach our code -- note this is not done until possible failures have been
    // taken into account. If the code goes to "fail" before this then the INIT
    // will be deallocated automatically when the file is closed during the startup sequence
    DetachResource(myInit);

    // display the good startup icon
    ShowInitIcon(resGoodInitIcon,true);
    goto end;
fail:
    // deallocate globals if something failed
    if(myMenu) DisposeMenu(myMenu);
    // and show the bad icon
    ShowInitIcon(resBadInitIcon,true);
end:
    // clean up before leaving
    SetA4(oldA4);
}

// This is a shell jGNEFilter based on Apple sample code
// I just added two instructions to check for nil jGNEFilters

pascal asm void myJGNEShell(void)
{
    // on input: a1 has event record ptr, d0 has result
    movea.l        d0,a0
    jsr            SetUpA4
    move.l        d0,-(sp)        // save old A4 on the stack
    move.l        a0,d0
    tst.b        inJGNE            // don't be reentrant
    bne.s        skipOver
    move.b        #true,inJGNE
    move.w        d0,-(sp)        // push parameters
    move.l        a1,-(sp)
    jsr            myGNE            // call the C function below
    movea.l        (sp)+,a1
    addq.l        #2,sp
    asl.w        #8,d0            // emulate GNE bug ("bump C Boolean to Lisa")
    move.w        d0,0x0008(sp)
    move.b        #false,inJGNE
skipOver:
    movea.l        gOldJGNE,a0        // get previous jGNE
    movea.l        (sp)+,a4        // restore A4
    // I added these two instructions to check for a nil jGNEFilter
    cmpa.l        #0,a0            // is the previous jGNEFilter nil?
    beq.s        bail            // if so, then bail
    move.l        a0,-(sp)        // return to previous jGNE filter
bail:
    rts                            // return to caller of my jGNE
}

// This is the C function called from the assembly code shell above
// It is the main function for the filter

Boolean myGNE(EventRecord *event, Boolean preResult)
{
    Boolean postResult = preResult;

    if (preResult                                    // another jGNE didn't process this already
            && (event->what == mouseDown)            // it's a mouse down event
            && (event->modifiers & cmdKey)
            && (event->modifiers & controlKey))        // with some modifier keys held down
    {
        // this is the current menu bar -- do not modify this since it isn't a copy!
        MenuListHdl        theList = (MenuListHdl)LMGetMenuList();

        if (theList && *theList && myMenu && *myMenu)            // make sure everything seems to be OK
        {
            MenuHandle    appMenu;

            // Get the application menu
            // Since this already has a nice list of applications,
            // I just borrow the items from this list to save time and space
            // Note: this is also not a copy so don't modify it!
            // (Kind of a nasty hack but it works -- and it also gives us notification mgr stuff)
            appMenu = FindTheAppMenu(theList);
            if (appMenu)
            {
                SInt32        numItems, sepItem;
                SInt32        mResult;

                // this is where we borrow the items and set up our menu
                numItems = SetUpTheMenu(appMenu, &sepItem);
                if (numItems)
                {
                    // here's the actual pop-up menu!
                    mResult = PopUpMenuSelect(myMenu,event->where.v,event->where.h,1);
                    // get rid of it as soon as possible
                    TearDownTheMenu(numItems);
                    // now respond to whatever was selected (if something was)
                    if (HighWord(mResult)==kMyMenuID)
                        RespondToTheMenu(LowWord(mResult), numItems, appMenu, sepItem);
                }
                // make sure the mouse down doesn't fall through and get processed by anything
                event->what = nullEvent;
                event->modifiers = 0L;
                postResult = false;
            }
        }
    }
    return postResult;
}

// this just looks at the current menu bar and gets the application system menu
// it returns 0 if it couldn't be found for some reason

MenuHandle FindTheAppMenu(MenuListHdl theList)
{
    MenuHandle    temp;
    SInt32        numMenus = (*theList)->lastMenu/6;    // 6 bytes per menu in mArray

    while(numMenus--)
    {
        temp = (*theList)->mArray[numMenus].menuoH;
        // note: we need to check more than just that the handle is non-null since
        // some things add weird stuff to the menu bar at times
        if(IsValidHandle(temp)&&(*temp)->menuID==kAppMenuID) return temp;
    }
    return 0L;
}

// this sets up the popup menu by copying the application names from the application menu

SInt32 SetUpTheMenu(MenuHandle appMenu, SInt32 *sepItemNum)
{
    SInt32        appItemNum, myItemNum = 0L, numAppItems = CountMItems(appMenu);
    Str255        text;
    SInt16        mark;

    for(appItemNum=1L;appItemNum<=numAppItems;appItemNum++)
    {
        // get the item info
        GetMenuItemText(appMenu,appItemNum,text);
        if(!myItemNum)
        {
            // skip the items before (and including) the separator
            // we could hard code this and just start at item 5 but
            // what if the format of the application menu changes?
            // since we use this again later, save off the separator
            // item number so we don't have to do this again
            if(*text==1 && text[1]=='-')
            {
                myItemNum++;
                *sepItemNum = appItemNum;
            }
            continue;
        }
        GetItemMark(appMenu,appItemNum,&mark);

        // add this item to our menu
        AppendMenu(myMenu,"\p ");
        SetMenuItemText(myMenu,myItemNum,text);
        if(mark==noMark || mark==checkMark || mark==diamondMark)
        {
            // this adds the check mark for the front application
            // and also will add diamond marks for notification manager things
            SetItemMark(myMenu,myItemNum,mark);
            // make sure it's enabled
            EnableItem(myMenu,myItemNum);
        }
        else
        {
            // we've got a submenu or something that needs to be dealt with
            // so don't deal with it
            DisableItem(myMenu,myItemNum);
        }
        myItemNum++;
    }
    // add our menu to the current menu list in preparation for popping up
    if(myItemNum)
    {
        InsertMenu(myMenu,hierMenu);
        myItemNum--;    // remember we incremented at the end of the loop
                        // note: if separator is last item this function still returns 0
    }
    return myItemNum;
}

// this just cleans up and should be self-explanatory

void TearDownTheMenu(SInt32 numItems)
{
    DeleteMenu(kMyMenuID);    // remove from the menu list
    while(numItems--)DeleteMenuItem(myMenu,1);    // clear it out internally
}

// this processes a hit on our menu

void RespondToTheMenu(SInt16 item, SInt32 numItems, MenuHandle appMenu, SInt32 sepItemNum)
{
    SInt16        mark;

    // make sure its a valid hit
    if (item > numItems || item < 1) return;
    // adjust for looking into the application menu (see SetUpTheMenu)
    item += sepItemNum;
    // get the mark from the application menu (we've already destroyed our menu)
    GetItemMark(appMenu,item,&mark);
    // we only switch if its not frontmost (i.e. no check mark) and not hierarchical
    if (mark==noMark || mark==diamondMark)
    {
        Str63                    hitName, findName;
        ProcessSerialNumber        psn;
        ProcessInfoRec            info;
        OSErr                    myErr = noErr;

        // get the application name
        GetMenuItemText(appMenu,item,hitName);
        // now get the serial number of that application
        psn.lowLongOfPSN = kNoProcess;
        psn.highLongOfPSN = 0L;
        while(!myErr)
        {
            myErr = GetNextProcess(&psn);
            if (!myErr)
            {
                // make sure these are reset before each info call since they get trashed by the call
                info.processInfoLength = sizeof(ProcessInfoRec);
                info.processName = findName;
                info.processAppSpec = nil;
                myErr = GetProcessInformation(&psn,&info);
                if (!myErr && pStrComp(findName,hitName))
                {
                    // we got its serial number!
                    // now the real response: bring that application to the front
                    // note that, since we're using the system application menu,
                    // we won't be bringing a background-only app to the front
                    SetFrontProcess(&psn);
                    break;
                }
            }
        }
    }
}

// I use these string utilities a lot
// they are fast but do not do any error checking

// This is a byte by byte comparison of two strings so it obviously
// doesn't handle capitalization, diacritical marks, etc.

Boolean pStrComp(StringPtr p1, StringPtr p2)
{
    register SInt32        ln = *p1;
    do{if(*p1++!=*p2++)return false;}while(ln--);
    return true;
}

// This copies p1 into p2
// Make sure beforehand that you have enough space in p2!

void pStrCopy (StringPtr p1, StringPtr p2)
{
    register SInt32        ln = *p1;
    do{*p2++=*p1++;}while(ln--);
    // note: you could also do BlockMoveData((Ptr)p1,(Ptr)p2,*p1+1)
    // but why use the toolbox overhead for a few bytes of copying?
}